.TH std::ranges::zip_transform_view::iterator 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::ranges::zip_transform_view::iterator \- std::ranges::zip_transform_view::iterator

.SH Synopsis
   template< bool Const >  (since C++23)
   class /*iterator*/;     (exposition only*)

   The iterator type of a possibly const-qualified zip_transform_view, returned by
   zip_transform_view::begin and in certain cases by zip_transform_view::end.

   The type /*iterator*/<true> or /*iterator*/<false> treats the underlying views as
   const-qualified or non-const-qualified respectively.

.SH Member types

   Member type       Definition
                     zip_transform_view if Const is false, const zip_transform_view
   Parent (private)  otherwise.
                     (exposition-only member type*)
   Base (private)    InnerView if Const is false, const InnerView otherwise.
                     (exposition-only member type*)
                     Let /*maybe-const*/<Const, F>& denote const F& if Const is true,
                     F& otherwise.
                     Let /*maybe-const*/<Const, Views> denote const Views if Const is
                     true, Views otherwise.

                     Let /*POT*/ denote the pack of types
                     std::iterator_traits<std::iterator_t<
                         /*maybe-const*/<Const, Views>>>::iterator_category...

                     If /*Base*/ models forward_range, then iterator_category denotes:

                       * std::input_iterator_tag, if
                         std::invoke_result_t</*maybe-const*/<Const, F>&,
                             ranges::range_reference_t</*maybe-const*/<Const,
                         Views>>...>

   iterator_category is not a reference.
   (optional)          * Otherwise,

                       * std::random_access_iterator_tag, if

                     (std::derived_from</*POT*/, std::random_access_iterator_tag> &&
                     ...) is true.
                       * Otherwise, std::bidirectional_iterator_tag, if

                     (std::derived_from</*POT*/, std::bidirectional_iterator_tag> &&
                     ...) is true.
                       * Otherwise, std::forward_iterator_tag, if

                     (std::derived_from</*POT*/, std::forward_iterator_tag> && ...) is
                     true.
                       * Otherwise, std::input_iterator_tag.

                     Not present if /*Base*/ does not model forward_range.
   iterator_concept  /*ziperator*/<Const>::iterator_concept
                     Let /*RREF*/ be ranges::range_reference_t<Views>...,
                     and /*CRREF*/ be ranges::range_reference_t<const Views>.... Then:

   value_type          * std::remove_cvref_t<std::invoke_result_t<F&, /*RREF*/>> if
                         Const is false,
                       * std::remove_cvref_t<std::invoke_result_t<const F&, /*CRREF*/>>
                         otherwise.
   difference_type   range::range_difference_t</*Base*/>

   Data members

   Member object     Definition
   parent_ (private) A pointer Parent* to the parent object
                     (exposition-only member object*)
   inner_ (private)  An iterator of type ziperator<Const>.
                     (exposition-only member type*)

.SH Member functions

   constructor     constructs an iterator
   (C++23)         \fI(public member function)\fP
   operator*       obtains the result of applying the invocable object to the
   (C++23)         underlying poined-to elements
                   \fI(public member function)\fP
   operator[]      obtains the result of applying the invocable object to the
   (C++23)         underlying elements at given offset
                   \fI(public member function)\fP
   operator++
   operator++(int)
   operator--      advances or decrements the underlying iterator
   operator--(int) \fI(public member function)\fP
   operator+=
   operator-=
   (C++23)

.SH Non-member functions

   operator==  compares the underlying iterators
   operator<=> \fI(function)\fP
   (C++23)
   operator+   performs iterator arithmetic on underlying iterators
   operator-   \fI(function)\fP
   (C++23)

.SH Example

    This section is incomplete
    Reason: no example

.SH Category:
     * Todo no example
